Astronomie TypeScript : Implémentation des types de corps célestes

            
interface CelestialBody {
  name: string;
  mass: number; // en kg
  radius: number; // en mètres
  position: { x: number; y: number; z: number }; // en mètres
  velocity: { x: number; y: number; z: number }; // en m/s
}

            

              
                Copy
              
            
          

            
interface Planet extends CelestialBody {
  orbitalPeriod: number; // en jours terrestres
  hasAtmosphere: boolean;
  numberOfMoons: number;
}

            

              
                Copy
              
            
          

            
interface Star extends CelestialBody {
  temperature: number; // en Kelvin
  luminosity: number; // relative au Soleil
  spectralType: string; // par ex., "G2V"
}

            

              
                Copy
              
            
          

            
interface Moon extends CelestialBody {
  orbitalPeriod: number; // en jours terrestres
  parentPlanet: string; // Nom de la planète qu'elle orbite
  isTidallyLocked: boolean;
}

            

              
                Copy
              
            
          

            
class PlanetImpl implements Planet {
  name: string;
  mass: number;
  radius: number;
  position: { x: number; y: number; z: number };
  velocity: { x: number; y: number; z: number };
  orbitalPeriod: number;
  hasAtmosphere: boolean;
  numberOfMoons: number;

  constructor(name: string, mass: number, radius: number, position: { x: number; y: number; z: number }, velocity: { x: number; y: number; z: number }, orbitalPeriod: number, hasAtmosphere: boolean, numberOfMoons: number) {
    this.name = name;
    this.mass = mass;
    this.radius = radius;
    this.position = position;
    this.velocity = velocity;
    this.orbitalPeriod = orbitalPeriod;
    this.hasAtmosphere = hasAtmosphere;
    this.numberOfMoons = numberOfMoons;
  }

  describe(): string {
    return `Planet: ${this.name}, Mass: ${this.mass} kg, Radius: ${this.radius} m, Orbital Period: ${this.orbitalPeriod} days`;
  }
}

            

              
                Copy
              
            
          

            
const earth = new PlanetImpl(
  "Earth",
  5.972e24, // kg
  6.371e6, // mètres
  { x: 0, y: 0, z: 0 },
  { x: 0, y: 0, z: 0 },
  365.25, // jours
  true,
  1
);

console.log(earth.describe()); // Sortie : Planète : Terre, Masse : 5.972e+24 kg, Rayon : 6371000 m, Période orbitale : 365.25 jours

            

              
                Copy
              
            
          

            
class StarImpl implements Star {
  name: string;
  mass: number;
  radius: number;
  position: { x: number; y: number; z: number };
  velocity: { x: number; y: number; z: number };
  temperature: number;
  luminosity: number;
  spectralType: string;

  constructor(name: string, mass: number, radius: number, position: { x: number; y: number; z: number }, velocity: { x: number; y: number; z: number }, temperature: number, luminosity: number, spectralType: string) {
    this.name = name;
    this.mass = mass;
    this.radius = radius;
    this.position = position;
    this.velocity = velocity;
    this.temperature = temperature;
    this.luminosity = luminosity;
    this.spectralType = spectralType;
  }

  describe(): string {
    return `Star: ${this.name}, Temperature: ${this.temperature} K, Luminosity: ${this.luminosity} (Sun=1), Spectral Type: ${this.spectralType}`;
  }
}

            

              
                Copy
              
            
          

            
const sun = new StarImpl(
  "Sun",
  1.989e30, // kg
  6.957e8, // mètres
  { x: 0, y: 0, z: 0 },
  { x: 0, y: 0, z: 0 },
  5778, // Kelvin
  1, // relative au Soleil
  "G2V"
);

console.log(sun.describe()); // Sortie : Étoile : Soleil, Température : 5778 K, Luminosité : 1 (Soleil=1), Type spectral : G2V

            

              
                Copy
              
            
          

            
class MoonImpl implements Moon {
  name: string;
  mass: number;
  radius: number;
  position: { x: number; y: number; z: number };
  velocity: { x: number; y: number; z: number };
  orbitalPeriod: number;
  parentPlanet: string;
  isTidallyLocked: boolean;

  constructor(name: string, mass: number, radius: number, position: { x: number; y: number; z: number }, velocity: { x: number; y: number; z: number }, orbitalPeriod: number, parentPlanet: string, isTidallyLocked: boolean) {
    this.name = name;
    this.mass = mass;
    this.radius = radius;
    this.position = position;
    this.velocity = velocity;
    this.orbitalPeriod = orbitalPeriod;
    this.parentPlanet = parentPlanet;
    this.isTidallyLocked = isTidallyLocked;
  }

  describe(): string {
    return `Moon: ${this.name}, Orbiting: ${this.parentPlanet}, Orbital Period: ${this.orbitalPeriod} days, Tidally Locked: ${this.isTidallyLocked}`;
  }
}

            

              
                Copy
              
            
          

            
const moon = new MoonImpl(
  "Moon",
  7.347e22, // kg
  1.737e6, // mètres
  { x: 0, y: 0, z: 0 },
  { x: 0, y: 0, z: 0 },
  27.3, // jours
  "Earth",
  true
);

console.log(moon.describe()); // Sortie : Lune : Lune, En orbite autour de : Terre, Période orbitale : 27.3 jours, En rotation synchrone : true

            

              
                Copy
              
            
          

            
const celestialObjects: CelestialBody[] = [earth, sun, moon];

celestialObjects.forEach(obj => {
  console.log(obj.name);
});

            

              
                Copy
              
            
          

            
function displayOrbitalPeriod(body: CelestialBody): void {
  if ((body as Planet).orbitalPeriod !== undefined) {
    console.log(`Période orbitale : ${(body as Planet).orbitalPeriod} jours`);
  }
}

displayOrbitalPeriod(earth); // Sortie : Période orbitale : 365.25 jours
displayOrbitalPeriod(sun);   // Pas de sortie, car le soleil n'a pas de orbitalPeriod

// Une autre façon de faire une garde de type
function isPlanet(body: CelestialBody): body is Planet {
    return (body as Planet).orbitalPeriod !== undefined;
}

function displayOrbitalPeriod2(body: CelestialBody): void {
    if (isPlanet(body)) {
        console.log(`Période orbitale : ${body.orbitalPeriod} jours`);
    }
}

displayOrbitalPeriod2(earth); // Sortie : Période orbitale : 365.25 jours
displayOrbitalPeriod2(sun);   // Pas de sortie

            

              
                Copy
              
            
          

            
function calculateDistance(
  body1: T,
  body2: U
): number {
  const dx = body1.position.x - body2.position.x;
  const dy = body1.position.y - body2.position.y;
  const dz = body1.position.z - body2.position.z;
  return Math.sqrt(dx * dx + dy * dy + dz * dz);
}

const distance = calculateDistance(earth, moon);
console.log(`Distance entre la Terre et la Lune : ${distance} mètres`);

            

              
                Copy
              
            
          

            
// Constante gravitationnelle
const G = 6.674e-11;

function updatePlanetPosition(planet: Planet, star: Star, timeStep: number): void {
  // Calculer la distance entre la planète et l'étoile
  const dx = star.position.x - planet.position.x;
  const dy = star.position.y - planet.position.y;
  const dz = star.position.z - planet.position.z;
  const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);

  // Calculer la force gravitationnelle
  const force = (G * planet.mass * star.mass) / (distance * distance);

  // Calculer les composantes de la force
  const forceX = force * dx / distance;
  const forceY = force * dy / distance;
  const forceZ = force * dz / distance;

  // Calculer l'accélération
  const accelerationX = forceX / planet.mass;
  const accelerationY = forceY / planet.mass;
  const accelerationZ = forceZ / planet.mass;

  // Mettre à jour la vitesse
  planet.velocity.x += accelerationX * timeStep;
  planet.velocity.y += accelerationY * timeStep;
  planet.velocity.z += accelerationZ * timeStep;

  // Mettre à jour la position
  planet.position.x += planet.velocity.x * timeStep;
  planet.position.y += planet.velocity.y * timeStep;
  planet.position.z += planet.velocity.z * timeStep;
}

// Exemple d'utilisation
const mars = new PlanetImpl(
    "Mars",
    6.39e23,
    3.3895e6,
    { x: 2.279e11, y: 0, z: 0 }, // position de départ
    { x: 0, y: 24077, z: 0 }, // vitesse initiale
    687, // période orbitale
    true,
    2
);


const timeStep = 86400; // Un jour en secondes

for (let i = 0; i < 365; i++) {
  updatePlanetPosition(mars, sun, timeStep);
  //console.log(`Jour ${i + 1} : Position de Mars - X: ${mars.position.x}, Y: ${mars.position.y}`);
}

console.log(`Position finale de Mars - X: ${mars.position.x}, Y: ${mars.position.y}, Z: ${mars.position.z}`);

            

              
                Copy